home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’94 / [√] Distribution Restricted! / Steve Sisak / TMFutures / UFailure.c < prev    next >
Text File  |  1994-06-26  |  7KB  |  288 lines
  1. //----------------------------------------------------------------------------------------
  2. //UFailure.cp
  3. //Copyright © 1985-1993 Apple Computer, Inc.  All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UFAILURE__
  7. #include "UFailure.h"
  8. #endif
  9.  
  10. #ifndef __STDIO__
  11. #include <stdio.h>
  12. #endif
  13.  
  14. #ifndef __MEMORY__
  15. #include <Memory.h>
  16. #endif
  17.  
  18. #ifndef __RESOURCES__
  19. #include <Resources.h>
  20. #endif
  21.  
  22. #ifndef __ERRORS__
  23. #include <Errors.h>
  24. #endif
  25.  
  26. #ifndef qDebug
  27. #define qDebug 0
  28. #endif
  29.  
  30. FailInfoPtr gTopHandler = NULL;
  31.  
  32. //----------------------------------------------------------------------------------------
  33. // Assertion: 
  34. //----------------------------------------------------------------------------------------
  35. #pragma segment MAFailureRes
  36.  
  37. void Assertion(const Boolean condition, const StringPtr description)
  38. {
  39.     if (!condition)
  40.     {
  41.         Failure(minErr, 0);
  42.     }
  43. } // Assertion 
  44.  
  45. //----------------------------------------------------------------------------------------
  46. // FailMemError: 
  47. //----------------------------------------------------------------------------------------
  48. #pragma segment MAFailureRes
  49.  
  50. void FailMemError()
  51. {
  52.     OSErr e = MemError();
  53.  
  54.     if (e != noErr)
  55.         Failure(e, 0);
  56. } // FailMemError 
  57.  
  58. //----------------------------------------------------------------------------------------
  59. // FailNewMessage: 
  60. //----------------------------------------------------------------------------------------
  61. #pragma segment MAFailureRes
  62.  
  63. void FailNewMessage(OSErr error,
  64.                        long oldMessage,
  65.                        long newMessage)
  66. {
  67.     if (!oldMessage)
  68.         Failure(error, newMessage);
  69.     else
  70.         Failure(error, oldMessage);
  71. } // FailNewMessage 
  72.  
  73. //----------------------------------------------------------------------------------------
  74. // FailNIL: 
  75. //----------------------------------------------------------------------------------------
  76. #pragma segment MAFailureRes
  77.  
  78. void FailNIL(void* p)
  79. {
  80.     if (!p)
  81.         Failure(memFullErr, 0);
  82. } // FailNIL 
  83.  
  84. //----------------------------------------------------------------------------------------
  85. // FailNILResource: 
  86. //----------------------------------------------------------------------------------------
  87. #pragma segment MAFailureRes
  88.  
  89. void FailNILResource(Handle r)
  90. {
  91.     OSErr e;
  92.  
  93.     if (!r)
  94.     {
  95.         e = ResError();
  96.         if (e == noErr)
  97.             e = resNotFound;
  98.         Failure(e, 0);
  99.     }
  100. } // FailNILResource 
  101.  
  102. //----------------------------------------------------------------------------------------
  103. // FailOSErr: 
  104. //----------------------------------------------------------------------------------------
  105. #pragma segment MAFailureRes
  106.  
  107. void FailOSErr(OSErr error)
  108. {
  109.     if (error != noErr)
  110.         Failure(error, 0);
  111. } // FailOSErr 
  112.  
  113. //----------------------------------------------------------------------------------------
  114. // ErrorIs: 
  115. // return true if error == expectedError
  116. //          false if error == noErr
  117. //          otherwise fail
  118. //----------------------------------------------------------------------------------------
  119. #pragma segment MAFailureRes
  120.  
  121. Boolean ErrorIs(OSErr expectedError, OSErr error)
  122. {
  123.     if (error == noErr)
  124.         return true;
  125.     
  126.     if (error != expectedError)
  127.         Failure(error, 0);
  128.     
  129.     return true;
  130. } // FailOSErr 
  131.  
  132. //----------------------------------------------------------------------------------------
  133. // FailResError: 
  134. //----------------------------------------------------------------------------------------
  135. #pragma segment MAFailureRes
  136.  
  137. void FailResError()
  138.  
  139. {
  140.     OSErr e = ResError();
  141.  
  142.     if (e != noErr)
  143.         Failure(e, 0);
  144. } // FailResError 
  145.  
  146. //----------------------------------------------------------------------------------------
  147. // Failure: 
  148. //----------------------------------------------------------------------------------------
  149. #pragma segment MAFailureRes
  150.  
  151. void Failure(OSErr error,
  152.                 long message)
  153.  
  154. {
  155.     FailInfoPtr pf = gTopHandler;
  156.     if (pf)
  157.     {
  158.         // pop the stack first, because calling the handler is likely to result in a call
  159.         // to Failure
  160.         gTopHandler = pf->nextInfo;
  161.  
  162. #if 000
  163.         if (CanWriteLn() && ((error != noErr) || gIntenseDebugging))// only show 0 errors if _really_ looking
  164.         {
  165.             GetCallersMethodName(pWho);
  166.             fprintf(stderr, "Failure signaled by: %s\n", (char *) pWho);
  167.             fprintf(stderr, "        error: %1d message: %1d (%1d/%1d)\n", error, message, message >> 16, message & 0x0000FFFF);
  168.         }
  169. #endif
  170.  
  171.         pf->error     = error;
  172.         pf->message  = message;
  173.         longjmp(pf->savedState,0);                // Go execute the failure handler
  174.     }
  175.     else
  176.     {
  177.         if (qDebug)
  178.             ProgramBreak("\pFailure called, but no handler!");
  179.         
  180.         // The following ExitToShell allows the application to fail somewhat gracefully
  181.         // in the case that an allocation request has failed during static initialization.
  182.         ExitToShell();
  183.     }
  184. } // Failure 
  185.  
  186. //----------------------------------------------------------------------------------------
  187. // ProgramBreak: 
  188. //----------------------------------------------------------------------------------------
  189. #pragma segment MAFailureRes
  190.  
  191. void ProgramBreak(const StringPtr grievance)
  192. {
  193.     StringPtr report = grievance;
  194.     
  195. #if 0
  196.     ConfirmHighLevelDebugger();
  197.     
  198.     if (gHighLevelDebuggerRunning)
  199.         SysBreakStr(report);
  200.     else
  201.         DebugStr(report);
  202. #else
  203.     DebugStr(report);
  204. #endif
  205.  
  206. } // ProgramBreak 
  207.  
  208. //----------------------------------------------------------------------------------------
  209. // ProgramReport: 
  210. //----------------------------------------------------------------------------------------
  211. #pragma segment MAFailureRes
  212.  
  213. void ProgramReport(const StringPtr grievance,
  214.                     const Boolean
  215. #if qDebug
  216. breakInDebugger
  217. #endif
  218. )
  219.  
  220. {
  221. //    CStr255 report = grievance + "\n";
  222.     StringPtr report = grievance;
  223.  
  224. #if 0
  225.     ConfirmHighLevelDebugger();
  226.     
  227.     if (gHighLevelDebuggerRunning)
  228.     {
  229.         if (breakInDebugger)
  230.             SysBreakStr(report);
  231.         else
  232.             SysBreakFunc(report);
  233.     }
  234.     else
  235.         DebugStr(report);
  236. #else
  237.     DebugStr(report);
  238. #endif
  239.  
  240. } // ProgramReport 
  241.  
  242. //----------------------------------------------------------------------------------------
  243. // HandlerExists: 
  244. //----------------------------------------------------------------------------------------
  245. #pragma segment MAFailureRes
  246.  
  247. Boolean HandlerExists(FailInfoPtr testFailInfoPtr)
  248. {
  249.     FailInfoPtr pf = gTopHandler;
  250.  
  251.     while (pf)
  252.     {
  253.         if (pf == testFailInfoPtr)
  254.             return true;
  255.         pf = pf->nextInfo;
  256.     }
  257.     return false;
  258. } // HandlerExists 
  259.  
  260. //----------------------------------------------------------------------------------------
  261. // Success: 
  262. //----------------------------------------------------------------------------------------
  263. #pragma segment MAFailureRes
  264.  
  265. void Success(FailInfo* fi)
  266. {
  267. #if 0
  268.     if (gTopHandler != &fi)
  269.     {
  270.         CStr255 msg;
  271.     
  272.         fprintf(stderr, "gTopHandler: %p, parameter: %p\n", gTopHandler, &fi);
  273.         msg = "Problem with Success: ";
  274.         if (HandlerExists(&fi))
  275.             msg += "too few ";
  276.         else
  277.             msg += "too many ";
  278.         msg += "calls to Success";
  279.         ProgramBreak(msg);
  280.     }
  281.  
  282.     fi.installed = false;
  283. #endif
  284.  
  285.     gTopHandler = fi->nextInfo;
  286. } // Success 
  287.  
  288.